import re
import string  # for generating test data

# imports
import pytest  # used for our unit tests
from code_to_optimize.remove_control_chars import CharacterRemover

# unit tests

@pytest.fixture
def remover():
    """Fixture to provide a CharacterRemover instance."""
    return CharacterRemover()


# 1. Basic Test Cases

def test_empty_string(remover):
    """Test that an empty string returns an empty string."""
    codeflash_output = remover.remove_control_characters("")

def test_no_control_characters(remover):
    """Test that a string with no control characters is unchanged."""
    codeflash_output = remover.remove_control_characters("Hello, World!")

def test_only_control_characters(remover):
    """Test that a string with only control characters returns an empty string."""
    control_chars = "".join(chr(i) for i in list(range(0, 32)) + [127])
    codeflash_output = remover.remove_control_characters(control_chars)

def test_mixed_control_and_printable(remover):
    """Test a string with interleaved control and printable characters."""
    s = "A\x00B\x1FC\x7FD"
    expected = "ABCD"
    codeflash_output = remover.remove_control_characters(s)

def test_control_characters_at_start_end(remover):
    """Test control characters at the start and end of the string."""
    s = "\x00\x1FHello, World!\x7F\x0A"
    expected = "Hello, World!"
    codeflash_output = remover.remove_control_characters(s)

def test_control_characters_in_middle(remover):
    """Test control characters in the middle of the string."""
    s = "foo\x00bar\x1Fbaz"
    expected = "foobarbaz"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_newline_and_tab(remover):
    """Test that tabs and newlines (which are control characters) are removed."""
    s = "Line1\nLine2\tEnd"
    expected = "Line1Line2End"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_unicode_but_no_control(remover):
    """Test that non-ASCII unicode characters are preserved."""
    s = "Café 漢字 🚀"
    expected = "Café 漢字 🚀"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_unicode_and_control(remover):
    """Test that unicode is preserved and control characters are removed."""
    s = "\x00Café\x1F 漢字 🚀\x7F"
    expected = "Café 漢字 🚀"
    codeflash_output = remover.remove_control_characters(s)

# 2. Edge Test Cases

def test_none_input(remover):
    """Test that passing None returns an empty string."""
    codeflash_output = remover.remove_control_characters(None)

def test_all_ascii_printable(remover):
    """Test that all printable ASCII characters are preserved."""
    s = string.printable
    # Remove control characters from string.printable (tab, newline, carriage return, etc.)
    expected = "".join(c for c in s if c not in ''.join(chr(i) for i in list(range(0, 32)) + [127]))
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_only_del(remover):
    """Test that DEL character (ASCII 127) is removed."""
    s = "foo" + chr(127) + "bar"
    expected = "foobar"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_surrogate_pairs(remover):
    """Test that surrogate pairs (high unicode) are preserved."""
    s = "Test \U0001F600 \U0001F4A9"
    expected = s
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_extended_ascii(remover):
    """Test that extended ASCII (128-255) is preserved."""
    s = "".join(chr(i) for i in range(128, 256))
    expected = s
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_only_one_control_character(remover):
    """Test that a string with only one control character returns empty string."""
    codeflash_output = remover.remove_control_characters("\x1B")

def test_string_with_adjacent_control_characters(remover):
    """Test that adjacent control characters are all removed."""
    s = "A\x00\x01\x02B"
    expected = "AB"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_control_character_just_outside_range(remover):
    """Test that characters just outside the control range are preserved."""
    s = "A" + chr(32) + chr(126) + chr(128) + "Z"
    expected = s
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_repeated_control_characters(remover):
    """Test that multiple repeated control characters are all removed."""
    s = "\x00\x00foo\x1F\x1Fbar\x7F\x7F"
    expected = "foobar"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_mixed_line_endings(remover):
    """Test that CR, LF, and CRLF are all removed."""
    s = "A\r\nB\nC\rD"
    expected = "ABCD"
    codeflash_output = remover.remove_control_characters(s)

# 3. Large Scale Test Cases

def test_large_string_no_control_characters(remover):
    """Test a large string with no control characters (should be unchanged)."""
    s = "A" * 1000
    expected = s
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_all_control_characters(remover):
    """Test a large string composed only of control characters (should return empty)."""
    s = "".join(chr(i % 32) for i in range(1000))
    expected = ""
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_mixed(remover):
    """Test a large string with control characters every 10th character."""
    base = "abcdefghij"
    s = ""
    for i in range(100):  # 1000 characters
        s += base[:9] + chr(i % 32)
    expected = "abcdefghi" * 100
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_unicode_and_control(remover):
    """Test a large string with interleaved unicode and control characters."""
    unicode_chars = "漢字🚀"
    s = ""
    for i in range(250):
        s += unicode_chars + chr(i % 32)
    expected = unicode_chars * 250
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_with_del(remover):
    """Test a large string with DEL (ASCII 127) interleaved."""
    s = ("foo" + chr(127)) * 250
    expected = "foo" * 250
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_with_printable_and_control(remover):
    """Test a string of 1000 printable ASCII characters, each followed by a control character."""
    s = ""
    for i in range(500):
        s += chr(65 + (i % 26)) + chr(i % 32)
    expected = "".join(chr(65 + (i % 26)) for i in range(500))
    codeflash_output = remover.remove_control_characters(s)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import re
import string  # used for generating test data

# imports
import pytest  # used for our unit tests
from code_to_optimize.remove_control_chars import CharacterRemover

# unit tests

@pytest.fixture
def remover():
    """Fixture to provide a CharacterRemover instance."""
    return CharacterRemover()

# 1. Basic Test Cases

def test_ascii_letters_and_digits_untouched(remover):
    # Letters and digits should not be removed
    s = "HelloWorld123"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_newline_and_tab(remover):
    # Newline (\n) and tab (\t) are control characters and should be removed
    s = "Hello\nWorld\t123"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_mixed_control_and_printable(remover):
    # Mix of printable and control characters
    s = "A\x00B\x1FC\x7FD"
    # \x00, \x1F, \x7F are control characters and should be removed
    codeflash_output = remover.remove_control_characters(s)

def test_no_control_characters(remover):
    # No control characters, string should be unchanged
    s = "Just a normal sentence!"
    codeflash_output = remover.remove_control_characters(s)

def test_only_control_characters(remover):
    # Only control characters, should return empty string
    s = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x7F"
    codeflash_output = remover.remove_control_characters(s)

def test_empty_string(remover):
    # Empty string should return empty string
    codeflash_output = remover.remove_control_characters("")

def test_none_input(remover):
    # None input should return empty string (as per implementation)
    codeflash_output = remover.remove_control_characters(None)

def test_space_and_punctuation_untouched(remover):
    # Spaces and punctuation are not control characters and should remain
    s = "Hello, world! How are you?"
    codeflash_output = remover.remove_control_characters(s)

# 2. Edge Test Cases

def test_string_with_all_ascii_control_characters(remover):
    # String containing all ASCII control characters (0x00-0x1F and 0x7F)
    control_chars = ''.join(chr(i) for i in list(range(0x00, 0x20)) + [0x7F])
    codeflash_output = remover.remove_control_characters(control_chars)

def test_string_with_unicode_non_ascii_control(remover):
    # Unicode control characters outside ASCII range should NOT be removed
    # e.g., \u200B (zero width space), \u2028 (line separator)
    s = "A\u200BB\u2028C"
    # These are not in [\x00-\x1F\x7F], so should remain
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_surrogate_pairs(remover):
    # Surrogate pairs (e.g., emoji) should not be removed
    s = "Smile: \U0001F600"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_mixed_line_endings(remover):
    # CR (\r) and LF (\n) are both control characters and should be removed
    s = "Line1\r\nLine2\rLine3\nLine4"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_null_bytes(remover):
    # Null bytes (\x00) should be removed
    s = "abc\x00def\x00ghi"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_bell_and_escape(remover):
    # Bell (\x07) and escape (\x1B) are control characters and should be removed
    s = "Start\x07Middle\x1BEnd"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_extended_ascii(remover):
    # Extended ASCII (0x80-0xFF) are not control characters and should remain
    s = "A" + "".join(chr(i) for i in range(0x80, 0x100)) + "Z"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_only_space(remover):
    # Space is not a control character and should remain
    s = "     "
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_control_characters_at_edges(remover):
    # Control characters at start and end
    s = "\x00Hello World\x7F"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_multiple_consecutive_control_characters(remover):
    # Multiple consecutive control characters in the middle
    s = "abc\x00\x01\x02def"
    codeflash_output = remover.remove_control_characters(s)

def test_string_with_mixed_control_and_non_ascii(remover):
    # Mix of control characters and non-ASCII unicode
    s = "A\x00Bé\x1FC\u20AC\x7FD"
    codeflash_output = remover.remove_control_characters(s)

# 3. Large Scale Test Cases

def test_large_string_only_control_characters(remover):
    # Large string of only control characters should return empty string
    s = "".join(chr(i % 32) for i in range(1000))  # 1000 control chars
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_no_control_characters(remover):
    # Large string with no control characters should remain unchanged
    s = "A" * 1000 + "B" * 1000 + "C" * 1000
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_some_control_characters(remover):
    # Large string with control characters interleaved
    s = "".join("A" + chr(0x00) + "B" + chr(0x1F) + "C" + chr(0x7F) for _ in range(300))
    expected = "ABC" * 300
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_with_unicode_and_control(remover):
    # Large string with unicode and control characters mixed
    s = "".join("é" + chr(0x00) + "Ω" + chr(0x1F) + "€" + chr(0x7F) for _ in range(300))
    expected = "éΩ€" * 300
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_alternating_control_and_printable(remover):
    # Alternating control and printable characters
    s = "".join(chr(0x00 + (i % 32)) + chr(65 + (i % 26)) for i in range(500))
    expected = "".join(chr(65 + (i % 26)) for i in range(500))
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_with_spaces_and_control(remover):
    # Large string with spaces and control characters
    s = (" " * 500) + "".join(chr(i % 32) for i in range(500))
    expected = " " * 500
    codeflash_output = remover.remove_control_characters(s)

def test_large_string_with_all_ascii_characters(remover):
    # String with all ASCII characters, control characters should be removed
    s = "".join(chr(i) for i in range(128)) * 5  # 5 times all ASCII
    expected = "".join(chr(i) for i in range(32, 127)) * 5  # printable ASCII (32-126)
    codeflash_output = remover.remove_control_characters(s)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.